home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / utilities / misc / show1.0.lha / show / RCS / prefs_actions.c,v < prev    next >
Encoding:
Text File  |  1994-12-07  |  11.9 KB  |  441 lines
  1. head    1.21;
  2. access;
  3. symbols
  4.     fontscreen:1.1;
  5. locks; strict;
  6. comment    @ * @;
  7.  
  8.  
  9. 1.21
  10. date    94.12.07.02.33.27;    author jsshephe;    state Exp;
  11. branches;
  12. next    ;
  13.  
  14.  
  15. desc
  16. @Actions when gadgets and menu items are pressed.
  17. @
  18.  
  19.  
  20. 1.21
  21. log
  22. @Made a little correction in teh PREFS_DELETEClicked that remove a gcc warning.
  23. @
  24. text
  25. @#include <exec/types.h>
  26. #include <intuition/intuition.h>
  27. #include <libraries/gadtools.h>
  28. #include <libraries/asl.h>
  29. #include <stdio.h>
  30. #include <stdlib.h>
  31. #include "showprefs.h"
  32.  
  33. /* protos */
  34. #ifdef __OPTIMIZE__
  35. #include <inline/intuition.h>
  36. #include <inline/gadtools.h>
  37. #include <inline/exec.h>
  38. #include <inline/asl.h>
  39. #include <inline/dos.h>
  40. #else
  41. #include <clib/intuition_protos.h>
  42. #include <clib/gadtools_protos.h>
  43. #include <clib/asl_protos.h>
  44. #include <clib/exec_protos.h>
  45. #include <clib/dos_protos.h>
  46. #endif
  47.  
  48. #ifdef __GNUC__
  49. inline
  50. #endif
  51. struct SuffixList *FindNode(struct List *list, int number) {
  52.     struct SuffixList *node= (struct SuffixList *)Suffix_List->lh_Head;
  53.     int i;
  54.  
  55.     for (i=0; i < number; i++, node=(struct SuffixList *)node->sl_Node.ln_Succ) {};
  56.     return node;
  57. }
  58.  
  59. /* routine when gadget "Suffixes" in ListView is clicked. */
  60. int PREFS_SUFFIXESClicked( struct IntuiMessage *msg, struct Gadget **PrefsGadgets ) {
  61.     struct SuffixList *node = FindNode(Suffix_List, msg->Code);
  62.  
  63.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_SUFFIX],PrefsWnd,NULL,
  64.     GTST_String, node->sl_Node.ln_Name,
  65.     (TAG_DONE) );
  66.  
  67.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_COMMAND],PrefsWnd,NULL,
  68.     GTST_String, node->command,
  69.     (TAG_DONE) );
  70.  
  71.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_ASYNCH],PrefsWnd,NULL,
  72.     GTCB_Checked, node->Asynch,
  73.     (TAG_DONE) );
  74.  
  75.     /* GadgetID stores # in list of selected suffix */
  76.     PrefsGadgets[PREFS_ASYNCH]->GadgetID =
  77.     PrefsGadgets[PREFS_SUFFIX]->GadgetID =
  78.     PrefsGadgets[PREFS_COMMAND]->GadgetID = msg->Code;
  79.  
  80.     #ifdef debug
  81.     printf("Number put in  node is %d\n",PrefsGadgets[PREFS_SUFFIX]->GadgetID);
  82.     #endif
  83.  
  84.     return TRUE;
  85. }
  86.  
  87. /* routine when gadget "Save" is clicked. */
  88. int PREFS_SAVEClicked( struct IntuiMessage *msg, struct Gadget **PrefsGadgets ) {
  89.     SavePrefs("env:show.prefs");
  90.     SavePrefs("envarc:show.prefs");
  91.     return FALSE;
  92. }
  93.  
  94. /* routine when gadget "Suffix" is clicked. */
  95. int PREFS_SUFFIXClicked( struct IntuiMessage *msg, struct Gadget **PrefsGadgets ) {
  96.     struct SuffixList *node;
  97.  
  98.    if (PrefsGadgets[PREFS_SUFFIX]->GadgetID != (UWORD)-1) {
  99.     node = FindNode(Suffix_List, PrefsGadgets[PREFS_SUFFIX]->GadgetID);
  100.  
  101.     #ifdef debug
  102.         printf("Number of node is %d\n",PrefsGadgets[PREFS_SUFFIX]->GadgetID);
  103.         printf("previous suffix %s\n",node->sl_Node.ln_Name);
  104.     #endif
  105.  
  106.     /* turn off the list first and then restore it */
  107.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_SUFFIXES],PrefsWnd,NULL,
  108.         (GTLV_Labels), ~0,
  109.         (TAG_DONE) );
  110.  
  111.     strcpy(node->sl_Node.ln_Name,GetString(PrefsGadgets[PREFS_SUFFIX]));
  112.  
  113.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_SUFFIXES],PrefsWnd,NULL,
  114.         (GTLV_Labels), Suffix_List,
  115.         (TAG_DONE) );
  116.     }
  117.     return TRUE;
  118. }
  119.  
  120. /* routine when gadget "Command" is clicked. */
  121. int PREFS_COMMANDClicked( struct IntuiMessage *msg, struct Gadget **PrefsGadgets ) {
  122.     struct SuffixList *node;
  123.  
  124.     if (PrefsGadgets[PREFS_COMMAND]->GadgetID != (UWORD)-1) {
  125.     node = FindNode(Suffix_List, PrefsGadgets[PREFS_COMMAND]->GadgetID);
  126.  
  127.     #ifdef debug
  128.         printf("Number of node is %d\n",PrefsGadgets[PREFS_COMMAND]->GadgetID);
  129.         printf("previous command %s\n",node->command);
  130.     #endif
  131.  
  132.     /* turn off the list first and then restore it */
  133.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_SUFFIXES],PrefsWnd,NULL,
  134.         (GTLV_Labels), ~0,
  135.         (TAG_DONE) );
  136.  
  137.     strcpy(node->command,GetString(PrefsGadgets[PREFS_COMMAND]));
  138.  
  139.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_SUFFIXES],PrefsWnd,NULL,
  140.         (GTLV_Labels), Suffix_List,
  141.         (TAG_DONE) );
  142.     }
  143.  
  144.     return TRUE;
  145. }
  146.  
  147. /* routine when gadget "Asynchronous" is clicked. */
  148. int PREFS_ASYNCHClicked( struct IntuiMessage *msg, struct Gadget **PrefsGadgets ) {
  149.     struct SuffixList *node;
  150.  
  151.     if (PrefsGadgets[PREFS_ASYNCH]->GadgetID != (UWORD)-1) {
  152.     node = FindNode(Suffix_List, PrefsGadgets[PREFS_ASYNCH]->GadgetID);
  153.  
  154.     #ifdef debug
  155.         printf("Number of node is %d\n",PrefsGadgets[PREFS_ASYNCH]->GadgetID);
  156.         printf("previous asynch is  %d\n",node->Asynch);
  157.     #endif
  158.  
  159.     /* turn off the list first and then restore it */
  160.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_SUFFIXES],PrefsWnd,NULL,
  161.         (GTLV_Labels), ~0,
  162.         (TAG_DONE) );
  163.  
  164.     node->Asynch = (PrefsGadgets[PREFS_ASYNCH]->Flags & GFLG_SELECTED) ? TRUE : FALSE;
  165.  
  166.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_SUFFIXES],PrefsWnd,NULL,
  167.         (GTLV_Labels), Suffix_List,
  168.         (TAG_DONE) );
  169.     }
  170.  
  171.     return TRUE;
  172. }
  173.  
  174. /* routine when gadget "Cancel" is clicked. */
  175. int PREFS_CANCELClicked( struct IntuiMessage *msg, struct Gadget **PrefsGadgets ) {
  176.     return FALSE;
  177. }
  178.  
  179. /* routine when gadget "New" is clicked. */
  180. int PREFS_NEWClicked( struct IntuiMessage *msg, struct Gadget **PrefsGadgets ) {
  181.     struct SuffixList *NewNode = MakeNode("(New Suffix)","",TRUE);
  182.  
  183.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_SUFFIXES],PrefsWnd,NULL,
  184.     (GTLV_Labels), ~0,
  185.     (TAG_DONE) );
  186.  
  187.     if (NewNode != NULL) {
  188.     AddHead(Suffix_List,(struct Node *)NewNode);
  189.  
  190.  
  191.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_SUFFIX],PrefsWnd,NULL,
  192.         GTST_String, NewNode->sl_Node.ln_Name,
  193.         (TAG_DONE) );
  194.  
  195.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_COMMAND],PrefsWnd,NULL,
  196.         GTST_String, NewNode->command,
  197.         (TAG_DONE) );
  198.  
  199.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_ASYNCH],PrefsWnd,NULL,
  200.         GTCB_Checked, NewNode->Asynch,
  201.         (TAG_DONE) );
  202.  
  203.     /* GadgetID stores # in list of selected suffix */
  204.     PrefsGadgets[PREFS_ASYNCH]->GadgetID =
  205.     PrefsGadgets[PREFS_SUFFIX]->GadgetID =
  206.     PrefsGadgets[PREFS_COMMAND]->GadgetID = 0;
  207.     }
  208.     else {
  209.     Error("New suffix not created. Low on memory.");
  210.     }
  211.  
  212.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_SUFFIXES],PrefsWnd,NULL,
  213.     (GTLV_Labels), Suffix_List,
  214.     (TAG_DONE) );
  215.  
  216.     return TRUE;
  217. }
  218.  
  219.  
  220. /* routine when gadget "Copy" is clicked. */
  221. int PREFS_COPYClicked( struct IntuiMessage *msg, struct Gadget **PrefsGadgets ) {
  222.  
  223.     struct SuffixList *NewNode;
  224.     struct SuffixList *node;
  225.  
  226.     if (PrefsGadgets[PREFS_SUFFIX]->GadgetID != (UWORD)-1) {
  227.     node = FindNode(Suffix_List, PrefsGadgets[PREFS_SUFFIX]->GadgetID);
  228.  
  229.     /* turn off the list first and then restore it */
  230.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_SUFFIXES],PrefsWnd,NULL,
  231.         (GTLV_Labels), ~0,
  232.         (TAG_DONE) );
  233.  
  234.     NewNode= MakeNode(node->sl_Node.ln_Name,node->command, node->Asynch);
  235.  
  236.     if (NewNode != NULL) {
  237.         AddHead(Suffix_List,(struct Node *)NewNode);
  238.  
  239.         GT_SetGadgetAttrs(PrefsGadgets[PREFS_SUFFIX],PrefsWnd,NULL,
  240.         GTST_String, NewNode->sl_Node.ln_Name,
  241.         (TAG_DONE) );
  242.  
  243.         GT_SetGadgetAttrs(PrefsGadgets[PREFS_COMMAND],PrefsWnd,NULL,
  244.         GTST_String, NewNode->command,
  245.         (TAG_DONE) );
  246.  
  247.         GT_SetGadgetAttrs(PrefsGadgets[PREFS_ASYNCH],PrefsWnd,NULL,
  248.         GTCB_Checked, NewNode->Asynch,
  249.         (TAG_DONE) );
  250.  
  251.         /* GadgetID stores # in list of selected suffix */
  252.         PrefsGadgets[PREFS_ASYNCH]->GadgetID =
  253.         PrefsGadgets[PREFS_SUFFIX]->GadgetID =
  254.         PrefsGadgets[PREFS_COMMAND]->GadgetID = 0;
  255.  
  256.     }
  257.     else {
  258.         Error("Suffix not copied. Low on memory.");
  259.     }
  260.  
  261.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_SUFFIXES],PrefsWnd,NULL,
  262.         (GTLV_Labels), Suffix_List,
  263.         (TAG_DONE) );
  264.  
  265.     } /* if */
  266.     return TRUE;
  267. }
  268.  
  269. /* routine when gadget "Delete" is clicked. */
  270. int PREFS_DELETEClicked( struct IntuiMessage *msg, struct Gadget **PrefsGadgets ) {
  271.     struct SuffixList *node;
  272.  
  273.     if (PrefsGadgets[PREFS_SUFFIX]->GadgetID != (UWORD)-1) {
  274.     node = FindNode(Suffix_List, PrefsGadgets[PREFS_SUFFIX]->GadgetID);
  275.  
  276.     /* turn off the list first and then restore it */
  277.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_SUFFIXES],PrefsWnd,NULL,
  278.     (GTLV_Labels), ~0,
  279.     (TAG_DONE) );
  280.  
  281.     Remove((struct Node *)node);
  282.     ResetGadgets(PrefsGadgets);
  283.     }
  284.     return TRUE;
  285. }
  286.  
  287. int PREFS_USEClicked( struct IntuiMessage *msg, struct Gadget **PrefsGadgets ) {
  288.    /* routine when gadget "Use" is clicked. */
  289.     SavePrefs("env:show.prefs");
  290.     return FALSE;
  291. }
  292.  
  293. /* routine when (sub)item "Open..." is selected. */
  294. int PrefsPREFS_OPEN( struct Gadget **PrefsGadgets ) {
  295.  
  296.     struct FileRequester *fr;
  297.     char file[MAX_LENGTH];
  298.  
  299.     if (fr = (struct FileRequester *)AllocAslRequestTags(ASL_FileRequest,
  300.         ASLFR_Window,        PrefsWnd,
  301.         ASLFR_TitleText,        "Load Show Preferences",
  302.         ASLFR_InitialDrawer,    "SYS:prefs/presets",
  303.         ASLFR_InitialFile,        "show.presets",
  304.         ASLFR_InitialPattern,   "#?.(prefs|presets)",
  305.         ASLFR_Flags1,        FILF_PATGAD,
  306.         TAG_DONE)) {
  307.  
  308.     if (AslRequest(fr,NULL)) {
  309.         strcpy(file,fr->rf_Dir);
  310.         AddPart(file,fr->rf_File,MAX_LENGTH);
  311.         LoadPrefs(file,PrefsGadgets,FALSE,NULL);
  312.     }
  313.     FreeAslRequest(fr);
  314.     }
  315.     else {
  316.     Error("Cannot allocate filerequester. Low on memory.");
  317.     }
  318.     return TRUE;
  319. }
  320.  
  321. /* routine when (sub)item "About" is selected. */
  322. int PrefsPREFS_ABOUT( struct Gadget **PrefsGadgets ) {
  323.     static struct EasyStruct es = {
  324.     sizeof(struct EasyStruct),
  325.     0,
  326.     "ShowPrefs About",
  327.     "Prefs Version 1.0\n"
  328.     "©1994 by Jeff Shepherd\n"
  329.     "Send comments and suggestions to\n"
  330.     "jsshephe@@undergrad.math.uwaterloo.ca\n"
  331.     "Read my home page at: http://www.undergrad.math.uwaterloo.ca/~jsshephe/index.html",
  332.     "OK"
  333.     };
  334.  
  335.     EasyRequestArgs(PrefsWnd, &es, NULL, NULL);
  336.     return TRUE;
  337. }
  338.  
  339. /* routine when (sub)item "Quit" is selected. */
  340. int PrefsPREFS_QUIT( struct Gadget **PrefsGadgets ) {
  341.     return FALSE;
  342. }
  343.  
  344. /* routine when (sub)item "Last Saved" is selected. */
  345. int PrefsPREFS_LAST( struct Gadget **PrefsGadgets ) {
  346.     LoadPrefs("envarc:show.prefs",PrefsGadgets,FALSE,NULL);
  347.     return TRUE;
  348. }
  349.  
  350. /* routine when (sub)item "Save as..." is selected. */
  351. int PrefsPREFS_SAVEAS( struct Gadget **PrefsGadgets ) {
  352.  
  353.     struct FileRequester *fr;
  354.     char file[MAX_LENGTH];
  355.  
  356.     if (fr = (struct FileRequester *)AllocAslRequestTags(ASL_FileRequest,
  357.         ASLFR_Window,        PrefsWnd,
  358.         ASLFR_TitleText,        "Save Show Preferences",
  359.         ASLFR_InitialDrawer,    "SYS:prefs/presets",
  360.         ASLFR_InitialFile,        "show.presets",
  361.         ASLFR_Flags1,        FILF_PATGAD | FILF_SAVE,
  362.         TAG_DONE)) {
  363.  
  364.     if (AslRequest(fr,NULL)) {
  365.         strcpy(file,fr->rf_Dir);
  366.         AddPart(file,fr->rf_File,MAX_LENGTH);
  367.         SavePrefs(file);
  368.     }
  369.     FreeAslRequest(fr);
  370.     }
  371.     else {
  372.     Error("Cannot allocate filerequester. Low on memory.");
  373.     }
  374.  
  375.     return TRUE;
  376. }
  377.  
  378. /* routine when (sub)item "Restore" is selected. */
  379. int PrefsPREFS_RESTORE( struct Gadget **PrefsGadgets )   {
  380.     struct SuffixList *node, *NewNode;
  381.  
  382.     /* turn off the list first and then restore it */
  383.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_SUFFIXES],PrefsWnd,NULL,
  384.     (GTLV_Labels), ~0,
  385.     (TAG_DONE) );
  386.  
  387.     Destroy_List(Suffix_List);
  388.     for (node = (struct SuffixList *)Duplicate->lh_Head; node->sl_Node.ln_Succ;
  389.       node=(struct SuffixList *)node->sl_Node.ln_Succ) {
  390.     if (NewNode =MakeNode(node->sl_Node.ln_Name, node->command, node->Asynch)) {
  391.         AddTail(Suffix_List,(struct Node *)NewNode);
  392.     }
  393.     else {
  394.         Error("Suffix not copied. Low on memory.");
  395.     }
  396.     } /* for */
  397.  
  398.     ResetGadgets(PrefsGadgets);
  399.     return TRUE;
  400.  
  401. }
  402.  
  403. /* Load preference file and reset gadgets */
  404. void LoadPrefs(char *filename, struct Gadget **PrefsGadgets, BOOL Dup, struct List *DupList) {
  405.  
  406.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_SUFFIXES],PrefsWnd,NULL,
  407.     (GTLV_Labels), ~0,
  408.     (TAG_DONE) );
  409.  
  410.     Destroy_List(Suffix_List);
  411.     Load(filename,Dup,DupList);
  412.  
  413.     ResetGadgets(PrefsGadgets);
  414. }
  415.  
  416. /* reset suffix, command, Asynch gadgets */
  417. void ResetGadgets(struct Gadget **PrefsGadgets) {
  418.  
  419.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_SUFFIXES],PrefsWnd,NULL,
  420.     (GTLV_Labels), Suffix_List,
  421.     (TAG_DONE) );
  422.  
  423.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_SUFFIX],PrefsWnd,NULL,
  424.     GTST_String, "",
  425.     (TAG_DONE) );
  426.  
  427.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_COMMAND],PrefsWnd,NULL,
  428.     GTST_String, "",
  429.     (TAG_DONE) );
  430.  
  431.     GT_SetGadgetAttrs(PrefsGadgets[PREFS_ASYNCH],PrefsWnd,NULL,
  432.     GTCB_Checked, FALSE,
  433.     (TAG_DONE) );
  434.  
  435.     /* GadgetID stores # in list of selected suffix */
  436.     PrefsGadgets[PREFS_ASYNCH]->GadgetID =
  437.     PrefsGadgets[PREFS_SUFFIX]->GadgetID =
  438.     PrefsGadgets[PREFS_COMMAND]->GadgetID = (UWORD)-1;
  439. }
  440. @
  441.